package com.ubigate.CooknaviHA;

//import static com.ubigate.CooknaviPlayer.AssetReader.getImageFromAsset;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;

import android.app.Activity;
import android.app.Dialog;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.media.MediaPlayer;
import android.media.MediaPlayer.OnCompletionListener;
import android.os.Bundle;
import android.speech.RecognitionListener;
import android.speech.RecognizerIntent;
import android.speech.SpeechRecognizer;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

public class ViewStepActivity extends Activity implements OnClickListener, OnCompletionListener {
	private static final String TAG = "ViewStepActivity";
	private static final int VOICE_RECOGNITION_REQUEST_CODE = 1234;		// 음성인식 요청 코드 상수설정

	int nVCommand = VOICE_RECOGNITION_REQUEST_CODE;		//	nVCommand에 대입
	
	/*
	 * 각 음성인식 코드에 대한 상수설정
	 */
	private static final int VC_INIT	= 1;
	private static final int VC_NEXT 	= 100;
	private static final int VC_LAST	= 150;
	private static final int VC_PREV 	= 200;
	private static final int VC_FIRST	= 250;
	private static final int VC_AGAIN	= 300;

//	private ProgressBar mProgress = null;			//프로그레스바
	private SpeechRecognizer recognizer = null;		//음성인식
	private Intent intent = null;		//	인텐트 선언
	private Dialog mDialog = null;		//	다이얼로그 선언
	
//	private SensorManager sensorManager;
//	private final int READY = 0, END=1, FINISH=2;			//핸들러 메시지. 음성인식 준비, 끝, 앱 종료
//	private Handler mHandler = new Handler(){
//		public void handleMessage(Message msg){
//			switch (msg.what) {
//			case READY:
////				mProgress.setVisibility(View.INVISIBLE);				//준비되었으면 프로그레스바 감춤
////				findViewById(R.id.stt_ui).setVisibility(View.VISIBLE);	//마이크 이미지 보임.
//				break;
//			case END:
////				mProgress.setVisibility(View.VISIBLE);						//말이 끝났으면 프로그레스바 출력(음성인식 중)
////				findViewById(R.id.stt_ui).setVisibility(View.INVISIBLE);	//마이크 이미지 감춤
//				sendEmptyMessageDelayed(FINISH, 5000);				//인식 시간 5초로 설정. 5초 지나면 신경안씀.
//				break;
//			case FINISH:
//				finish();														//앱 종료
//				break;
//			}
//		}
//	};
	
	private RecipeDetail recipeDetail;		//	RecipeDetail(CooknaviApp.java에 있음) 클래스 객체 생성
	
//	private Button voice_use_btn;
//	private Button voice_not_use_btn;

	/** Bottom Menu Button **/
	/*
	 * 이미지버튼, 이미지뷰, 텍스트뷰 변수선언
	 */
	private ImageButton btnHome = null;
	private ImageButton btnTimer = null;
	private ImageButton btnMetewand = null;
	private ImageButton btnMyrecipe = null;
	private ImageButton btnBack = null;

	private ImageView recipe_step_image;
	
	private TextView recipe_title;
	private TextView recipe_step_text;
	
	private TextView currentStep;
	private TextView lastStep;
	
	
	private Integer nStep = 1;
	private Integer nTotalSteps = 0;
	
//	private int nSensorType = 0;
	private Boolean bVGuidePlaying = false;		//	가이드재생 사용/비사용 상태
	private Boolean bVoiceEnabled = false;		//	음성인식 사용/비사용 상태
	private Boolean bNetworkEnabled = false;	//	네트워크 사용/비사용 상태
	private Boolean bExitActivity = false;		//	액티비티 종료 상태
	
	private String sContentPath = "";
	
	MediaPlayer mp = null;		//	미디어플레이어 객체 생성
	
	/** Called when the activity is first created. */
	/*
	 * 액티비티 주기
	 * (non-Javadoc)
	 * @see android.app.Activity#onCreate(android.os.Bundle)
	 */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
 
    	setContentView(R.layout.view_h);		// view_h.xml을 불러옴

    	Log.i(TAG, "onCreate");
    	//	디버깅 메시지 전송
       
    	sContentPath = ((CooknaviApp)getApplicationContext()).LoadContentPath();
    	//	컨텍스트의 경로를 가져와 저장
    	recipeDetail = ((CooknaviApp)getApplicationContext()).getDetailedRecipe();
    	//	레시피에 대한 디테일한 정보의 객체를 가져온다.
    	
        nTotalSteps = recipeDetail.getStepCount();
        //	레시피의 스텝의 갯수를 가져온다.
        
        // Bottom menu
        btnHome = (ImageButton) findViewById(R.id.btn_home);		//	홈 버튼
        btnTimer = (ImageButton) findViewById(R.id.btn_timer);		//	타이머 버튼
        btnMetewand = (ImageButton) findViewById(R.id.btn_metewand);//	계량측정 버튼
        btnMyrecipe = (ImageButton) findViewById(R.id.btn_myrecipe);//	마이레시피 버튼
        btnBack = (ImageButton) findViewById(R.id.btn_back);		//	뒤로가기 버튼
        
        /*
         * 버튼클릭시 오버라이딩된 onClick 함수가 실행되게끔 연결
         */
        btnHome.setOnClickListener(this);
        btnTimer.setOnClickListener(this);
        btnMetewand.setOnClickListener(this);
        btnMyrecipe.setOnClickListener(this);
        btnBack.setOnClickListener(this);

//      voice_not_use_btn.setVisibility(View.VISIBLE);
//		voice_use_btn.setVisibility(View.GONE);
        
        /*
         * view_h.xml의 각 id를 각 변수와 매핑시킴.
         */
        recipe_title = (TextView) findViewById(R.id.recipe_title);
        recipe_step_image = (ImageView) findViewById(R.id.recipe_step_image);
        recipe_step_text = (TextView) findViewById(R.id.recipe_step_text);
        
        currentStep = (TextView) findViewById(R.id.current_step);
        lastStep = (TextView) findViewById(R.id.last_step);
        
        recipe_title.setText(recipeDetail.getTitle());
        //	레시피의 타이틀을 가져와 recipe_title의 텍스트뷰에 뿌려줌.
        
//      sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);    
//		sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT), SensorManager.SENSOR_DELAY_FASTEST);
//		sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY), SensorManager.SENSOR_DELAY_FASTEST);

		setStep(nStep);	//	현재 액티비티의 setStep함수 실행

    	bVoiceEnabled = SpeechRecognizer.isRecognitionAvailable(this);
    	//	음성인식을 허용하도록 설정.
    	
    	//	
        if (((CooknaviApp)getApplicationContext()).getNetworkState() == 0) {
        	// 네트워크 연결 안됨
        	bNetworkEnabled = false;

        	Toast.makeText(ViewStepActivity.this, "인터넷에 연결되지 않으면 음성인식 기능을 사용할 수 없습니다.", Toast.LENGTH_LONG).show();
        	//	토스트박스에 위 메시지를 일정시간동안 뿌려줌.
        } else bNetworkEnabled = true;
        //	네트워크가 연결됨
        
    	if (bVoiceEnabled && bNetworkEnabled) {	//	음성인식이 허락되고, 네트워크가 연결되있으면
        	Log.d(TAG, "SpeechRecognizer createSpeechRecognizer");
        	//	디버깅 메시지 전송
        	intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);				//음성인식 intent생성
        	intent.putExtra(RecognizerIntent.EXTRA_CALLING_PACKAGE, getPackageName());	//데이터 설정
        	intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, "ko-KR");					//음성인식 언어 설정
//        	intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);

    		recognizer = SpeechRecognizer.createSpeechRecognizer(this);
    		//	새로운 음성인식 객체 생성
            recognizer.setRecognitionListener(listener);
            //	음성인식 리스너를 설정해줘서 콜백메서드가 호출될수있게함.
            //	Sets the listener that will receive all the callbacks.
    	}
	
    	mDialog = new Dialog(this);
    	//	다이얼로그 객체 생성
    	mDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    	//	다이얼로그 제목표시줄 없애기
    	mDialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
    	//	다이얼로그 윈도우창의 배경을 투명하게함
    	mDialog.getWindow().setBackgroundDrawable(getResources().getDrawable(R.drawable.hyunbin01));
    	//	다이얼로그 윈도우창에 현빈이미지(hyunbin01.png)를 뿌림
//    	mProgress = new ProgressBar(ViewStepActivity.this);
//    	mProgress.setIndeterminate(true);
    }

    @Override
    protected void onDestroy() {
    	super.onDestroy();	//	부모클래스의 onDestroy함수 사용
		Log.d(TAG, "onDestroy : V("+bVoiceEnabled+"),G("+bVGuidePlaying+"),N("+bNetworkEnabled+"),E("+bExitActivity+")");
		//	디버깅 로그 메시지 전송
    	bExitActivity = true;
    	//	액티비티 종료 설정
    	if (recognizer != null) {	//	음성인식기능이 널이 아니면(사용중이면)
    		recognizer.cancel();	//	기능을 중지하고
    		recognizer.destroy();	//	음석인식 자원 반환
    	}
    	if (mp.isPlaying()) { mp.stop(); mp.release(); }	//	미디어플레이어가 재생중이면 멈추고 릴리즈함.
    	else mp.release();	//	재생중이 아니면 그냥 릴리즈함.
    	mDialog.dismiss();	//	다이얼로그를 숨김(종료)

//    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)); 
//    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY));
    }

    @Override 
    protected void onStart() {
    	super.onStart();	//	부모클래스의 onStart 함수 실행
		Log.d(TAG, "onStart : V("+bVoiceEnabled+"),G("+bVGuidePlaying+"),N("+bNetworkEnabled+"),E("+bExitActivity+")");
		//	디버깅 로그 메시지 전송
//    	sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT), SensorManager.SENSOR_DELAY_FASTEST);
//    	sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY), SensorManager.SENSOR_DELAY_FASTEST);
    }  

    @Override 
    protected void onResume() {
    	super.onResume();	//	부모클래스의 onResume함수 실행
		Log.d(TAG, "onResume : V("+bVoiceEnabled+"),G("+bVGuidePlaying+"),N("+bNetworkEnabled+"),E("+bExitActivity+")");
		//	디버깅 로그 메시지 전송
        if (bVGuidePlaying) {	//	가이드가 재생중이면
    		mp.start();			//	미디어플레이어 실행
    	} else {				//	가이드가 재생중이 아니면
    		bVoiceEnabled = SpeechRecognizer.isRecognitionAvailable(this);
    		//	음성인식 사용 설정을 가져옴.
    		if (bVoiceEnabled) {	//	음성인식 사용중이면
    			recognizer.startListening(intent);	//	현재 intent를 실행
    		}
    	}
        bExitActivity = false;
        //	액티비티를 onResume했으므로 onPause에서해준 true를 바꿔줌.
        
//    	sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT), SensorManager.SENSOR_DELAY_FASTEST);
//    	sensorManager.registerListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY), SensorManager.SENSOR_DELAY_FASTEST);
    }  

    @Override 
    protected void onPause() {
    	super.onPause();	//	부모클래스에서의 onPause함수 실행
		Log.d(TAG, "onPause : V("+bVoiceEnabled+"),G("+bVGuidePlaying+"),N("+bNetworkEnabled+"),E("+bExitActivity+")");
		//	디버깅 로그 메시지 전송
		bExitActivity = true;
		//	액티비티를 멈췄으므로 true로 바꿔줌(다른 액티비티가 실행될수있기때문에)	
		//		if (mp != null) { bVGuidePlaying = mp.isPlaying(); }
//		else bVGuidePlaying = false;
    	if (bVGuidePlaying) {	//	가이드가 재생중이면
    		Log.d(TAG, "onPause : mp pause()");
    		//	디버깅	로그 메시지 전송
    		mp.pause(); 
    		//	미디어플레이어를 멈춤
    	}
    	if (bVoiceEnabled) {	// 음성인식이 사용중이면
//    		mProgress.setVisibility(View.INVISIBLE);
    		mDialog.hide();
    		//	다이얼로그를 숨김
    		recognizer.cancel();
    		//	음성인식을 취소함.
    		bVoiceEnabled = false;
    		//	음성인식을 사용하지못하게함
    	}
//    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)); 
//    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY));
    }
	
//    public void onAccuracyChanged(Sensor sensor, int accuracy) {
//		// TODO Auto-generated method stub
//    	int sensorType = sensor.getType(); 
//    	if (sensorType == Sensor.TYPE_LIGHT) Log.i(TAG, "onAccuracyChanged-Light ("+ accuracy +")");
//    	if (sensorType == Sensor.TYPE_PROXIMITY) Log.i(TAG, "onAccuracyChanged-Proximity ("+ accuracy +")");
//	}

//	public void onSensorChanged(SensorEvent event) {
//		// TODO Auto-generated method stub
//		if (!(bNetworkEnabled)) return;
//		
//		int sensorType = event.sensor.getType(); 
//		int iEventVal = (int)event.values[0];
//		float fEventVal = event.values[0];
//		float fDiffEventVal = fEventVal - (float)iEventVal;
//		
//		Log.i(TAG, "onSensorChanged - int value("+String.valueOf(iEventVal)+"), float value("+String.valueOf(fEventVal)+"), diff value("+String.valueOf(fDiffEventVal)+")");
//		if (sensorType == Sensor.TYPE_LIGHT) {
//			if (nSensorType == 0) nSensorType = sensorType;
//			if ((event.values[0] < 30) && (nSensorType == sensorType)) {
//				if (!(bVoiceEnabled)) {
//					Log.i(TAG, "onSensorChanged-Light ("+ event.values[0] +")");
//					startVoiceRecognitionActivity();
//					bVoiceEnabled = true;
////					voice_not_use_btn.setVisibility(View.GONE);
////					voice_use_btn.setVisibility(View.VISIBLE);
//				}
//			}
//		} else if (sensorType == Sensor.TYPE_PROXIMITY) {
//			if (nSensorType == 0) nSensorType = sensorType;
//			if ((event.values[0] > 0) && (event.values[0] <= 100)&& (nSensorType == sensorType) && (fDiffEventVal == 0.0)) {
//				Log.i(TAG, "onSensorChanged-Proximity ("+ event.values[0] +")");
//				
//				if (!(bVoiceEnabled)) {
//					startVoiceRecognitionActivity();
//					bVoiceEnabled = true;
////					voice_not_use_btn.setVisibility(View.GONE);
////					voice_use_btn.setVisibility(View.VISIBLE);
//				}				
//			}
//		}
//	}
    
    //	nStep에 따른 경로의 미디어플레이어를 재생시키는 함수
    private void setStep(Integer nStep) {
//		voice_not_use_btn.setVisibility(View.VISIBLE);
//		voice_use_btn.setVisibility(View.GONE);
    	this.nStep = nStep;	//	현재클래스의 nStep변수에 파라미터로 가져온 nStep을 넣음
    	String sAttachment = recipeDetail.getStepAttachment(nStep); 	
    	//	CooknaviApp.java의 RecipeDetail 클래스의 함수를 사용해 스트링에 넣어줌 
    	String sVAttachment = recipeDetail.getStepVoiceAttachment(nStep);
    	//	CooknaviApp.java의 RecipeDetail 클래스의 함수를 사용해 스트링에 넣어줌 
    	Log.i(TAG, "Va :"+sVAttachment+", a :"+sAttachment);
    	//	디버깅 로그 메시지 전송
    	Bitmap bm = BitmapFactory.decodeFile(sContentPath+"/"+sAttachment);
    	//	비트맵 객체를 생성하고 해당경로의 비트맵이미지 생성
    	Drawable dr = new BitmapDrawable(bm);
    	//	비트맵이미지를 그릴수있는 객체 생성
        //recipe_step_image.setImageBitmap(bm);
    	recipe_step_image.setBackgroundDrawable(dr);
    	//	배경이미지를 dr로 설정
        recipe_step_text.setText(recipeDetail.getStepDescription(nStep));
        //	텍스트를 recipeDetail.sDescription로 설정
        currentStep.setText(String.format("%02d", nStep));
        //	텍스트를 위 형태와 같이 설정
        lastStep.setText(String.format("|%02d", nTotalSteps));
        //	텍스트를 위 형태와 같이 설정
        if (recipeDetail.VGuideExist(nStep)) {	//	만약 sVGuide = on 일때(함수내용)
        	try {
				//AssetFileDescriptor afd = this.getAssets().openFd("audio/"+sVAttachment);
				FileInputStream fis = new FileInputStream(sContentPath+"/"+sVAttachment);
				//	위 경로로 바이트스트림 객체 생성
				FileDescriptor fd = fis.getFD();
				//	파일을 제어할수있는 객체 생성
				if (mp == null) mp = new MediaPlayer();
				//	미디어플레이어가 생성되지않았을경우 객체 생성
				else { mp.stop(); mp.reset(); }
				//	미디어플레이어가 생성되있을경우 멈추고 리셋함.
				mp.setOnCompletionListener(this);
				//	미디어플레이어에 리스너 설정
				mp.setDataSource(fd);
				//	미디어플레이어의 데이타소스를 fd로 설정
				fis.close();
				//	바이트스트림 닫기
				mp.prepare();
				//	reset 후 다시 사용 할경우 항상해야함. create는 자동으로 prepare함
				mp.start();
				//	미디어플레이어를 시작함
				bVGuidePlaying = true;
				//	현재 미디어플레이어가 사용중이므로 true로 바꿈
			} catch (IOException e) {
				// TODO Auto-generated catch block
				Log.d(TAG, e.getMessage());
			}
        } //else rest3Seconds();
   }

    @Override
	public void onClick(View v) {
		// TODO Auto-generated method stub
		int viewId = v.getId();	//	클릭시 현재 뷰의 id를 가져와서 대입
		Intent intent;
		switch (viewId) {
		case R.id.btn_home:	//	홈 버튼일 경우
			if (((CooknaviApp)getApplicationContext()).getNetworkState() > 0) {
				// 네트워크가 연결되어 있으면 CooknaviHAActivity로
				intent = new Intent(ViewStepActivity.this, CooknaviHAActivity.class);
				startActivity(intent);
				finish();
			} else {
				// 네트워크가 연결되어 있지 않으면 MyrecipeActivity로
				
			}
			break;
		case R.id.btn_timer: //	타이머 버튼일 경우
//			if (mp != null) {
//				mp.stop(); bVGuidePlaying = false;
//			}
//	    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)); 
//	    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY));

			//	TimerActivity로
			intent = new Intent(ViewStepActivity.this, TimerActivity.class);
            startActivity(intent);
			break;
			
		case R.id.btn_metewand:	// 계랑측정 버튼일 경우
//			if (mp != null) {
//				mp.stop();  bVGuidePlaying = false;
//			}
//	    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)); 
//	    	sensorManager.unregisterListener(this, sensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY));
            //	MetewandActivity로
			intent = new Intent(ViewStepActivity.this, MetewandActivity.class);
            startActivity(intent);
			break;
		case R.id.btn_myrecipe:	//	마이레시피 버튼일 경우
//			intent = new Intent(CooknaviHAActivity.this, WebviewActivity.class);
//			intent.putExtra("url", sSearchUrl);
//			startActivity(intent);
			break;
		case R.id.btn_back: 	//	뒤로가기 버튼일 경우
			onBackPressed(); 	//	뒤로가기함수 실행
			break;
		}
	}
		
	public void onCompletion(MediaPlayer mp) {
		// TODO Auto-generated method stub
		//rest3Seconds();
		Log.d(TAG, "onCompletion : V("+bVoiceEnabled+"),N("+bNetworkEnabled+"),E("+bExitActivity+")");
		//	디버깅 로그 메시지 전송
		bVGuidePlaying = false;
		//	플레이 완료 후 사용중이 아니므로 false
		// 요기에 컬러링 있는 경우 처리루틴 추가요... 
		bVoiceEnabled = SpeechRecognizer.isRecognitionAvailable(ViewStepActivity.this);
		//	현재 엑티비티의 음성인식 설정여부를 대입
		if (bVoiceEnabled && !bExitActivity) {	
			//	음성인식이 사용가능하고 현재 액티비티가 사용중이라면(끝나지않음)
	        recognizer.startListening(intent);	//	현재 인텐트 실행
		}
	}
	
//	public void rest3Seconds() {
//    	if (!(bVoiceEnabled)) return;
//		
//        Handler mHandler = new Handler();
//        mHandler.postDelayed(new Runnable() {
//        	// 메인으로 이동
//        	public void run()
//        	{        		
//        		startVoiceRecognitionActivity();
//        	}
//        }, 3000);
//	}
//
//	/** 음성인식 시작 **/
//    private void startVoiceRecognitionActivity() {
//    	try {
//	    	Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
//	    	intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
//	    	intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "음성 인식");
//	    	startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);
//    	} catch (ActivityNotFoundException ex) {
//    		Toast.makeText(this, "음성 인식이 불가능합니다.", Toast.LENGTH_LONG).show();
//    	}
//    }
//
//	/** 음성인식 결과 처리 **/
//	@Override
//	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
//		bVoiceEnabled = false;
////		voice_not_use_btn.setVisibility(View.VISIBLE);
////		voice_use_btn.setVisibility(View.GONE);
//
//		// 검색창에 검색어 입력
//		String sKeyword = "";
//		if (requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode == RESULT_OK) {
//			ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
//			sKeyword = matches.get(0).trim();
//		}
//		
//		super.onActivityResult(requestCode, resultCode, data);
//		
//		Log.i("Voice Recognition Result :", sKeyword);
//		if (sKeyword.equals("다음")) {
//			if (nStep < nTotalSteps) setStep(nStep+1);
//		} else if (sKeyword.equals("이전")) {
//			if (nStep > 1) setStep(nStep-1);
//		} else if (sKeyword.equals("다시")) {
//			setStep(nStep);
//		} else {
//			Toast.makeText(ViewStepActivity.this, "인식 결과가 올바르지 않습니다. 잠시후 다시 말씀 해주세요.", Toast.LENGTH_SHORT).show();
//		}
//	}

	//음성인식 리스너
	private RecognitionListener listener = new RecognitionListener() {
		//입력 소리 변경 시
		@Override public void onRmsChanged(float rmsdB) {
//			int step = (int)(rmsdB/7);		//소리 크기에 따라 step을 구함.
//			setVolumeImg(step);			//총 4단계 이미지 설정. 없음. 1단계, 2단계, 3단계
		}
		
		//음성 인식 결과 받음
		@Override public void onResults(Bundle results) {
//			mHandler.removeMessages(END);			//핸들러에 종료 메시지 삭제
//			mProgress.setVisibility(View.INVISIBLE);

			nVCommand = VOICE_RECOGNITION_REQUEST_CODE;
			
			ArrayList<String> arResults = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
			//	결과의 스트링배열리스트를 받아옴
			for(int index = 0; index < arResults.size(); index++) {
				String sResult = arResults.get(index).trim();
				//	인덱스번째의 공백문자열 제거
				if (sResult.equals("다음")) {	//	그 결과가 다음이고
					if (nStep < nTotalSteps) {	//	모든스텝수보다 작다면
						setStep(nStep+1);		//	스텝을 하나 더하고
						nVCommand = VC_NEXT;	//	다음 스텝 코드 대입
					} else {					//	현재 스텝수가 모든스텝수보다 작지 않다면(마지막이므로 다음 스텝 진행 불가능)
						nVCommand = VC_LAST;	//	마지막 스텝 코드 대입
					}
					break;
				} else if (sResult.equals("이전")) {	//	그 결과가 이전이고
					if (nStep > 1) {					//	스텝수가 맨처음보다 크다면
						setStep(nStep-1);				//	스텝수를 하나 빼고
						nVCommand = VC_PREV;			//	이전 스텝 코드 대입
					} else {							//	현재 스텝수가 처음이면(이전으로 갈수가없음)
						nVCommand = VC_FIRST;			//	맨 처음 스텝 코드 대입
					}
					break;
				} else if (sResult.equals("다시")) {	//	그 결과가 다시이면
					setStep(nStep);						//	스텝을 현재스텝으로 설정하고 
					nVCommand = VC_AGAIN;				//	다시 재생하는 코드 대입
					break;
				} else if (sResult.equals("빈아") || sResult.equals("비나") || sResult.equals("현빈씨")) {
					//	그 결과가 빈아 or 비나 or 현빈씨 이면
					nVCommand = VC_INIT;	//	초기화 코드 대입
			    	mDialog.getWindow().setBackgroundDrawable(getResources().getDrawable(R.drawable.hyunbin01));
			    	//	다이얼로그 윈도우창에 hyunbin01.png 이미지를 배경으로 뿌려줌
				} else if (sResult.equals("아이유") || sResult.equals("아이유야")) {
//					그 결과가 아이유 or 아이유야 이면	
					nVCommand = VC_INIT;	//	초기화 코드 대입
			    	mDialog.getWindow().setBackgroundDrawable(getResources().getDrawable(R.drawable.iu06));
			    	//	다이얼로그 윈도우창에 iu06.png 이미지를 배경으로 뿌려줌
				}
			}
	
			/*
			 * 각 코드에 대한 반응
			 * 1. 토스트박스로 메시지를 뿌려주고 인텐트를 통해 액티비티를 이동하거나
			 * 2. 아무것도 안함
			 */
			if (nVCommand == VOICE_RECOGNITION_REQUEST_CODE) {	//	음성인식실패
				Toast.makeText(ViewStepActivity.this, "음성 명령 인식에 실패 했습니다. 잠시 후 다시 입력해주세요.", 1000).show();
				Log.d(TAG, "RecognitionListener finish-인식 실패");
		        recognizer.startListening(intent);
			} else if (nVCommand == VC_LAST) {	//	현재스텝이 마지막임
				Log.d(TAG, "RecognitionListener finish-VC_LAST");
				Toast.makeText(ViewStepActivity.this, "마지막 단계입니다. 잠시 후 다시 입력해주세요.", 1000).show();
		        recognizer.startListening(intent);
			} else if (nVCommand == VC_FIRST) {	//	현재스텝이 처음임
				Log.d(TAG, "RecognitionListener finish-VC_FIRST");
				Toast.makeText(ViewStepActivity.this, "처음 단계입니다. 잠시 후 다시 입력해주세요.", 1000).show();
		        recognizer.startListening(intent);
			} else if (nVCommand == VC_INIT) {	//	현재 스텝이 초기화됨
				Log.d(TAG, "RecognitionListener finish-VC_INIT");
				Toast.makeText(ViewStepActivity.this, "명령어를 입력해주세요.", 1000).show();
		        recognizer.startListening(intent);
			} else if (nVCommand == VC_AGAIN) {	//	현재 스텝을 다시 보여줌
				Log.d(TAG, "RecognitionListener finish-VC_AGAIN");				
			} else {
				Log.d(TAG, "RecognitionListener finish-인식 성공 : "+nVCommand);
				//if(recognizer!= null) recognizer.stopListening();						//음성인식 중지
			}
			
		}
		
		//음성 인식 준비가 되었으면
		@Override public void onReadyForSpeech(Bundle params) {
//			mHandler.sendEmptyMessage(READY);		//핸들러에 메시지 보냄
			Log.d(TAG, "RecognitionListener onReadyForSpeech");
			if (nVCommand == VC_INIT) {	mDialog.show(); }
			//	현재 코드가 초기화이면 다이얼로그를 보여줌
		}
		
		//음성 입력이 끝났으면
		@Override public void onEndOfSpeech() {
//			mHandler.sendEmptyMessage(END);		//핸들러에 메시지 보냄
			Log.d(TAG, "RecognitionListener onEndOfSpeech");
			if (mDialog.isShowing()) mDialog.hide();
			//	다이얼로그가 보여주고있으면 다이얼로그를 숨김
//			mProgress.setVisibility(View.VISIBLE);
		}
		
		//에러가 발생하면
		/*
		 * 다양한 에러 코드에 따른
		 * 에러 이유를 밝힌다.
		 * (non-Javadoc)
		 * @see android.speech.RecognitionListener#onError(int)
		 */
		@Override public void onError(int error) {
//			mProgress.setVisibility(View.INVISIBLE);
			Log.d(TAG, "RecognitionListener onError");
			String msg = "";
			switch(error) {
			case SpeechRecognizer.ERROR_AUDIO:
				msg = "오디오 입력 중 오류가 발생했습니다.";
				break;
			case SpeechRecognizer.ERROR_CLIENT:
				msg = "단말에서 오류가 발생했습니다.";
				break;
			case SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS:
				msg = "권한이 없습니다.";
				break;
			case SpeechRecognizer.ERROR_NETWORK:
			case SpeechRecognizer.ERROR_NETWORK_TIMEOUT:
				msg = "네트워크 오류가 발생했습니다.";
				break;
			case SpeechRecognizer.ERROR_NO_MATCH:
				msg = "적당한 결과가 없습니다.";
				if (SpeechRecognizer.isRecognitionAvailable(ViewStepActivity.this)) {
					recognizer.startListening(intent);
				}
				break;
			case SpeechRecognizer.ERROR_RECOGNIZER_BUSY:
				msg = "음성인식 서비스가 과부하 되었습니다.";
				break;
			case SpeechRecognizer.ERROR_SERVER:
				msg = "서버에서 오류가 발생했습니다.";
				break;
			case SpeechRecognizer.ERROR_SPEECH_TIMEOUT:
				msg = "입력이 없습니다.";
				if (SpeechRecognizer.isRecognitionAvailable(ViewStepActivity.this)) {
					recognizer.startListening(intent);
				}
				break;
			}
			Log.d(TAG,msg);
		}

		/*
		 * 함수가 호출되도 지금은 아무 반응이 없음
		 * (non-Javadoc)
		 * @see android.speech.RecognitionListener#onBeginningOfSpeech()
		 */
		@Override public void onBeginningOfSpeech() {}							//입력이 시작되면
		@Override public void onPartialResults(Bundle partialResults) {}		//인식 결과의 일부가 유효할 때
		@Override public void onEvent(int eventType, Bundle params) {}			//미래의 이벤트를 추가하기 위해 미리 예약되어진 함수
		@Override public void onBufferReceived(byte[] buffer) {}				//더 많은 소리를 받을 때
	};
	
//	@Override
//	public void finish(){
//		Log.d(TAG, "RecognitionListener finish");
//		if(recognizer!= null) recognizer.stopListening();						//음성인식 중지
////		mHandler.removeMessages(READY);			//메시지 삭제
////		mHandler.removeMessages(END);			//메시지 삭제
////		mHandler.removeMessages(FINISH);			//메시지 삭제
////		super.finish();
//	}
//
}